home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / m2 / cat3src / cat / watchdog.i < prev    next >
Text File  |  1997-10-26  |  16KB  |  558 lines
  1. IMPLEMENTATION MODULE WatchDog;
  2.  
  3. (*==============================================================*
  4.  * Modul:               WatchDog Implementation                 *
  5.  * Autor:               Johannes G”ttker-Schnetmann, Dirk Steins*
  6.  * erstellt am:         April 1192                              *
  7.  * letzte Žnderung am:  06.04.1992                              *
  8.  * Version:             0.1                                     *
  9.  * Interne Version:     V#0003                                  *
  10.  *==============================================================*
  11.  * Interner Laberfilter fr CAT. Entstanden aus dem Watchdog-   *
  12.  * Accessory. Benutzt neben WatchDog.DAT noch Konfigurations-   *
  13.  * variablen, um festzustellen, welche Antwort CAT gegeben      *
  14.  * werden soll.                                                 *
  15.  *                                                              *
  16.  *==============================================================*)
  17.  
  18. FROM SYSTEM             IMPORT ADDRESS, ADR;
  19. FROM Storage            IMPORT ALLOCATE, DEALLOCATE;
  20. FROM StrConv            IMPORT CardToStr;
  21. IMPORT MagicAES, mtUtils;
  22. IMPORT Strings;
  23. IMPORT Lists;
  24. IMPORT mtTextfiles;
  25.  
  26. CONST
  27.       cr = 15C; lf = 12C; space = 40C;
  28.  
  29. (* Anzahl der zu testenden Namen -1 *)
  30.   maxNames = 10;
  31.  
  32.  
  33.   enableWatchDog  = 0;
  34.   disableWatchDog = 1;
  35.   CatAffirm       = 2;
  36.   CatAsk          = 3;
  37.   CatAccept       = 4;
  38.   CatForget       = 5;
  39.   CatGreetings    = 6;
  40.  
  41. (* Solche Infos verschickt Cat: *)
  42. TYPE strPtr = POINTER TO ARRAY[0..20000] OF CHAR;
  43.      smallPtr = POINTER TO ARRAY[0..255] OF CHAR;
  44.      MsgPtr  = POINTER TO RECORD
  45.                 PtrGruppe,
  46.                 PtrName,
  47.                 PtrBetreff : smallPtr;
  48.                 PtrText    : strPtr;
  49.                 TextLength : CARDINAL
  50.               END;
  51.  
  52. VAR
  53.  
  54. (* die allgemeinen Vars.. *)
  55.     applId, menuId,
  56.     events, return  : INTEGER;
  57.     
  58.     
  59. (* etwas aufwenigere Deklaration, wg. einfachem Zugriff *)
  60.     Mess    : RECORD
  61.                 MessType : CARDINAL;
  62.                 rest     : ARRAY[1..7] OF CARDINAL
  63.               END;
  64.     Look    : POINTER TO RECORD
  65.                messId : INTEGER;
  66.                apId   : INTEGER;
  67.                over   : INTEGER;
  68.                (* AccId, AccAcc *)
  69.                version, protoStep : CHAR;
  70.                name               : ADDRESS;
  71.                menuId             : INTEGER;
  72.                accId              : INTEGER;
  73.              END;
  74.     lm      : POINTER TO RECORD
  75.                 messId : CARDINAL;
  76.                 apId   : INTEGER;
  77.                 over   : INTEGER;
  78.                 catType: INTEGER;
  79.                 msg    : MsgPtr;
  80.                 isOn   : INTEGER
  81.               END;
  82.  
  83. (* der eigene Name, zum Senden fr XACC *)
  84.  
  85.     OurName : ARRAY[0..15] OF CHAR;
  86.  
  87. (* Hat sich Cat schon gemeldet? *)
  88.     catActive : BOOLEAN;
  89.     watchDogActive : BOOLEAN; (* Watchdog eingeschaltet? *)
  90.  
  91. (* Array fr die Namen, die erlaubt sind.. *)
  92.  
  93. TYPE  filtType  = (name, stich, text);
  94.       filterSet = SET OF filtType;
  95.       filtEntry = RECORD
  96.                     filter : filterSet;
  97.                     name   : smallPtr;
  98.                     stichw : smallPtr;
  99.                     ftext  : smallPtr;
  100.                     gruppe : ARRAY [0..10] OF CHAR;
  101.                     nameO,
  102.                     stichO,
  103.                     ftextO,
  104.                     gruppeO : BOOLEAN;
  105.                     filtCount: CARDINAL;
  106.                   END;
  107.      ptrFiltEntry = POINTER TO filtEntry;
  108. VAR    
  109.     filtList  : Lists.List;
  110.     voidO     : BOOLEAN;
  111.     lastGruppe : ARRAY [0..10] OF CHAR;
  112.     lastGrO   : BOOLEAN;
  113.  
  114.     globFiltCount,
  115.     messCount : CARDINAL;
  116. (*
  117. PROCEDURE dumpFiltList();
  118.   VAR e : ptrFiltEntry;
  119. BEGIN
  120.   Lists.ResetList (filtList);
  121.   e := Lists.NextEntry (filtList);
  122.   WHILE e # NIL DO
  123.     WriteString ('Gruppe: ');
  124.     WriteString (e^.gruppe);
  125.     IF e^.gruppeO THEN WriteString (' wird global gefiltert')
  126.     ELSE
  127.       WriteString (' wird nicht global gefiltert');
  128.     END;
  129.     WriteLn;
  130.     IF name IN e^.filter
  131.     THEN
  132.       WriteString ('Name: ');
  133.       WriteString (e^.name^);
  134.       IF ~e^.nameO THEN WriteString (' wird gefiltert.'); ELSE
  135.         WriteString (' wird nicht gefiltert');
  136.       END;
  137.       WriteLn;
  138.     END;
  139.     IF stich IN e^.filter
  140.     THEN
  141.       WriteString ('Betreff: ');
  142.       WriteString (e^.stichw^);
  143.       IF ~e^.stichO THEN WriteString (' wird gefiltert.'); ELSE
  144.         WriteString (' wird nicht gefiltert');
  145.       END;
  146.       WriteLn;
  147.     END;
  148.     IF text IN e^.filter
  149.     THEN
  150.       WriteString ('Text: ');
  151.       WriteString (e^.ftext^);
  152.       IF ~e^.ftextO THEN WriteString (' wird gefiltert.'); ELSE
  153.         WriteString (' wird nicht gefiltert');
  154.       END;
  155.       WriteLn;
  156.     END;
  157.     e := Lists.NextEntry (filtList);
  158.   END;
  159. END dumpFiltList;
  160. *)
  161.  
  162. PROCEDURE parseline (REF s : ARRAY OF CHAR);
  163. (* Folgende Tokens sind m”glich: 
  164.  * NAME=<filtname>;{ON|OFF};    Nachrichten von diesem Absender werden immer 
  165.  *                              gefiltert bzw. durchgelassen.                        
  166.  * GRUPPE=<filtGruppe>;{ON|OFF} Die Filtergruppe wird auf die Gruppe gesetzt.
  167.  * BETREFF=<stichwort>;{ON|OFF}; Wenn das Wort im Betreff vorkommt, wird gefiltert.
  168.  * TEXT=<text>;{ON|OFF};        Wenn der text enthalten ist, wird gefiltert.
  169.  *
  170.  * Die Schalter ON|OFF entscheiden darber, ob der filterbetreff immer akzeptiert wird,
  171.  * oder ob der Filterbetreff immer verworfen wird.
  172.  * Sollte einmal beides zutreffen, so wird nur dann gefiltert, wenn beide Bedingungen
  173.  * erfllt sind.
  174.  *)
  175.   VAR p, lastp : INTEGER;
  176.       entry : filtEntry;
  177.       str   : ARRAY [0..255] OF CHAR;
  178.       token : ARRAY [0..40] OF CHAR;
  179.       ptrEntry : ptrFiltEntry;
  180.       onoff : ARRAY [0..20] OF CHAR;
  181. BEGIN
  182.   p := 0;
  183.   lastp := 0;
  184.   WHILE p >= 0 DO
  185.     p := Strings.Pos ('=',s,p);
  186.     (* entry l”schen *)
  187.     WITH entry DO
  188.       filter := filterSet{};
  189.       name := NIL;
  190.       stichw := NIL;
  191.       ftext := NIL;
  192.       gruppe := '';
  193.     END;
  194.     (* Token holen *)
  195.     Strings.Copy (s,lastp,p-lastp,token,voidO);
  196.     IF Strings.StrEqual (token, "NAME")
  197.     THEN
  198.       INCL(entry.filter, name);
  199.       (* Namen holen *)
  200.       lastp := p+1;
  201.       p := Strings.Pos (';',s,lastp);
  202.       IF p>= 0 THEN
  203.         Strings.Copy (s, lastp, p-lastp, str, voidO);
  204.         ALLOCATE (entry.name, Strings.Length(str)+1);
  205.         IF entry.name # NIL
  206.         THEN
  207.           Strings.Assign (str, entry.name^, voidO);
  208.         END;
  209.         (* Schalter holen *)
  210.         lastp := p+1;
  211.         p := Strings.Pos (';',s,lastp);
  212.         IF p>= 0 THEN
  213.           Strings.Copy (s, lastp,p-lastp, str, voidO);
  214.           lastp := p+1;
  215.           IF Strings.StrEqual (str, 'ON')
  216.           THEN
  217.             entry.nameO := TRUE
  218.           ELSIF Strings.StrEqual (str, 'OFF')
  219.           THEN
  220.             entry.nameO := FALSE;
  221.           ELSE
  222.             EXCL (entry.filter, name);
  223.           END;
  224.         ELSE
  225.           EXCL (entry.filter, name);
  226.         END;
  227.       ELSE
  228.         EXCL (entry.filter, name);
  229.       END;
  230.     END;
  231.     (* Stichwort? *)
  232.     IF Strings.StrEqual (token, "BETREFF")
  233.     THEN
  234.       INCL(entry.filter, stich);
  235.       (* Betreff holen *)
  236.       lastp := p+1;
  237.       p := Strings.Pos (';',s,lastp);
  238.       IF p>= 0 THEN
  239.         Strings.Copy (s, lastp, p-lastp, str, voidO);
  240.         ALLOCATE (entry.stichw, Strings.Length(str)+1);
  241.         IF entry.stichw # NIL
  242.         THEN
  243.           Strings.Assign (str, entry.stichw^, voidO);
  244.         END;
  245.         (* Schalter holen *)
  246.         lastp := p+1;
  247.         p := Strings.Pos (';',s,lastp);
  248.         IF p>= 0 THEN
  249.           Strings.Copy (s, lastp,p-lastp, str, voidO);
  250.           lastp := p+1;
  251.           IF Strings.StrEqual (str, 'ON')
  252.           THEN
  253.             entry.stichO := TRUE
  254.           ELSIF Strings.StrEqual (str, 'OFF')
  255.           THEN
  256.             entry.stichO := FALSE;
  257.           ELSE
  258.             EXCL (entry.filter, stich);
  259.           END;
  260.         ELSE
  261.           EXCL (entry.filter, stich);
  262.         END;
  263.       ELSE
  264.         EXCL (entry.filter, stich);
  265.       END;
  266.     END;
  267.     (* Vorerst nicht, da ich nicht den gesamten Text in Upcase wandeln will
  268.      *
  269.     
  270.     (* Irgendein Text *)
  271.     IF Strings.StrEqual (token, "TEXT")
  272.     THEN
  273.       INCL(entry.filter, text);
  274.       (* ftextn holen *)
  275.       lastp := p+1;
  276.       p := Strings.Pos (';',s,lastp);
  277.       IF p>= 0 THEN
  278.         Strings.Copy (s, lastp, p-lastp, str, voidO);
  279.         ALLOCATE (entry.ftext, Strings.Length(str)+1);
  280.         IF entry.ftext # NIL
  281.         THEN
  282.           Strings.Assign (str, entry.ftext^, voidO);
  283.         END;
  284.         (* Schalter holen *)
  285.         lastp := p+1;
  286.         p := Strings.Pos (';',s,lastp);
  287.         IF p>= 0 THEN
  288.           Strings.Copy (s, lastp,p-lastp, str, voidO);
  289.           lastp := p+1;
  290.           IF Strings.StrEqual (str, 'ON')
  291.           THEN
  292.             entry.ftextO := TRUE
  293.           ELSIF Strings.StrEqual (str, 'OFF')
  294.           THEN
  295.             entry.ftextO := FALSE;
  296.           ELSE
  297.             EXCL (entry.filter, text);
  298.           END;
  299.         ELSE
  300.           EXCL (entry.filter, text);
  301.         END;
  302.       ELSE
  303.         EXCL (entry.filter, text);
  304.       END;
  305.     END;
  306.     
  307.     *)
  308.     
  309.     (* Gruppenname? *)
  310.     IF Strings.StrEqual (token, "GRUPPE")
  311.     THEN
  312.       (* ftextn holen *)
  313.       lastp := p+1;
  314.       p := Strings.Pos (';',s,lastp);
  315.       IF p>= 0 THEN
  316.         Strings.Copy (s, lastp, p-lastp, str, voidO);
  317.         lastp := p+1;
  318.         p := Strings.Pos (';',s, lastp);
  319.         IF p >= 0 THEN
  320.           Strings.Copy (s, lastp, p-lastp, onoff, voidO);
  321.           lastp := p+1;
  322.           IF Strings.StrEqual (onoff,'ON')
  323.           THEN
  324.             IF (Strings.Length(str) > 0) & (Strings.Length (str) <=10) 
  325.             THEN  
  326.               Strings.Assign (str, lastGruppe, voidO);
  327.               lastGrO := TRUE
  328.             END;
  329.           ELSIF Strings.StrEqual (onoff, 'OFF')
  330.           THEN
  331.             IF (Strings.Length(str) > 0) & (Strings.Length (str) <=10) 
  332.             THEN  
  333.               Strings.Assign (str, lastGruppe, voidO);
  334.               lastGrO := FALSE
  335.             END;
  336.           END;
  337.         END;
  338.       END;
  339.     END;
  340.     IF ~Strings.Empty (lastGruppe) & (entry.filter # filterSet{})
  341.     THEN
  342.       NEW (ptrEntry);
  343.       IF ptrEntry # NIL
  344.       THEN
  345.         ptrEntry^ := entry;
  346.         ptrEntry^.filtCount := 0;
  347.         Strings.Assign (lastGruppe,ptrEntry^.gruppe, voidO);
  348.         ptrEntry^.gruppeO := lastGrO;
  349.         Lists.AppendEntry (filtList, ptrEntry, voidO);
  350.       END;
  351.     END;
  352.   END;
  353. END parseline;
  354.  
  355. PROCEDURE getFiltList();
  356.   CONST filtFile  = 'watchdog.dat';
  357. VAR filtName : ARRAY [0..127] OF CHAR;
  358.     ft : mtTextfiles.TEXTFILE;
  359.     s  : ARRAY [0..255] OF CHAR;
  360. BEGIN
  361.   Lists.CreateList (filtList, voidO);
  362.   Strings.Assign (filtFile, filtName, voidO);
  363.   MagicAES.ShelFind (filtName);
  364.   IF mtTextfiles.OpenTextfile (filtName, mtTextfiles.READ, 8192, ft)
  365.   THEN
  366.     WHILE ~mtTextfiles.EndofText(ft) DO
  367.       mtTextfiles.ReadLine (ft, s);
  368.       mtTextfiles.ReadLn (ft);
  369.       Strings.Upper (s);
  370.       parseline (s);
  371.     END;
  372.     mtTextfiles.CloseTextfile (ft);
  373.   END;
  374. END getFiltList;
  375.  
  376. PROCEDURE SendID(Dest : CARDINAL);
  377. BEGIN
  378.   WITH Look^ DO
  379.     messId     := AccId;
  380.     apId       := applId;
  381.     over       := 0;
  382.     version    := 0C;
  383.     protoStep  := 0C;
  384.     name       := ADR(OurName);
  385.     menuId     := menuId;
  386.     accId      := 0;
  387.   END;
  388.   MagicAES.ApplWrite(Dest, 16, Look^);
  389. END SendID;
  390.  
  391. (*
  392. PROCEDURE WriteString (REF s : ARRAY OF CHAR);
  393. BEGIN
  394.   MagicDOS.Cconws (s);
  395. END WriteString;
  396.  
  397. PROCEDURE WriteLn();
  398. BEGIN
  399.   MagicDOS.Cconout (12C);
  400.   MagicDOS.Cconout (15C);
  401. END WriteLn;
  402. *)
  403.  
  404. PROCEDURE IsBad(REF msg : data.PtrRecord):BOOLEAN;
  405. (*
  406.  * Entscheidung, ob eine Msg durch darf, oder nicht.
  407.  *
  408.  *)
  409. VAR
  410.     gr     : ARRAY [0..20] OF CHAR;
  411.     abs    : ARRAY [0..100] OF CHAR;
  412.     weg    : ARRAY [0..40] OF CHAR;
  413.     
  414. VAR b : BOOLEAN;
  415.     z : CARDINAL;
  416.     e : ptrFiltEntry;
  417.     found,
  418.     accept : BOOLEAN;
  419.     grAccept : BOOLEAN;
  420. BEGIN
  421. (*
  422.  * -> die ersten drei kommen mit ihrem Pr„fix-Buchstaben,
  423.  * mužte ich eben feststellen..
  424.  *
  425.  *
  426.  
  427.   InOut.WriteLn;
  428.   InOut.WriteString(lm^.msg^.PtrGruppe^);
  429.   InOut.WriteLn;
  430.   InOut.WriteString(lm^.msg^.PtrName^);
  431.   InOut.WriteLn;
  432.   InOut.WriteString(lm^.msg^.PtrBetreff^);
  433. TYPE PtrRecord =
  434.        RECORD
  435.          pGruppe, pVon,         (* Absender,          Gruppe            *)
  436.          pWegen  : Str255Ptr;   (* Betreff,                             *)
  437.          pText   : BigTextPtr;  (* MsgText                              *)
  438.          TextMax : CARDINAL;
  439.          pId,                   (* Maus-ID der Mitteilung               *)
  440.          pRefNr,   pAn,         (* kommentierte Msg,  Empf„nger         *)
  441.          pEZeit,   pBSZeit,     (* Eingabezeit,       Bearb.status+Zeit *)
  442.          pMId,     pRId,        (* MessageID,         RId gem. Def      *)
  443.          pBox,                  (* Box gem. Def.                        *)
  444.          pName   : Str255Ptr;   (* Name gem. Def falls # Absenderangabe *)
  445.          txt     : mtTextfiles.TEXTFILE;
  446.          whatsThere : BITSET;
  447.        END;
  448. *)
  449.   (* G vor Gruppennamen entfernen *)
  450.   IF msg.pGruppe # NIL
  451.   THEN
  452.   Strings.Copy (msg^.PtrGruppe^, 1, 
  453.                 Strings.Length(lm^.msg^.PtrGruppe^)-1, gr, voidO);
  454.   END;
  455.   IF msg.pVon # NIL
  456.   THEN
  457.     Strings.Assign (msg.pVon^,abs, voidO);
  458.   ELSE
  459.     abs := '';
  460.   END;
  461.   IF msg.pWegen # NIL
  462.   THEN
  463.     Strings.Assign (msg.pWegen^,weg, voidO);
  464.   ELSE
  465.     weg := '';
  466.   END;
  467.   Strings.Upper (gr);  
  468.   Strings.Upper (abs);
  469.   Strings.Upper (weg);
  470.   
  471.   grAccept := FALSE;
  472.   
  473.   Lists.ResetList (filtList);
  474.   e := Lists.NextEntry (filtList);
  475.   accept := FALSE;        
  476.   found := FALSE;
  477.   WHILE e # NIL DO
  478.     IF Strings.StrEqual (e^.gruppe, gr) THEN
  479.       grAccept := e^.gruppeO;
  480.       (* Ja, der Eintrag geht ber diese Gruppe *)
  481.       IF name IN e^.filter
  482.       THEN
  483.         IF Strings.Pos (e^.name^, abs, 0) >= 0 THEN
  484.           (* Bedingung trifft zu *)
  485.           accept := accept OR e^.nameO;
  486.           found := TRUE;
  487.         END;
  488.       END;
  489.       IF stich IN e^.filter
  490.       THEN
  491.         IF Strings.Pos (e^.stichw^, weg,0) >= 0 THEN
  492.           (* Bedingung trifft zu *)
  493.           accept := accept OR e^.stichO;
  494.           found := TRUE;
  495.         END;
  496.       END;
  497.       (*
  498.       IF text IN e^.filter
  499.       THEN
  500.         IF Strings.Pos (e^.ftext^, msg.pText^,0) >= 0 THEN
  501.           (* Bedingung trifft zu *)
  502.           accept := accept OR e^.ftextO;
  503.           found := TRUE;
  504.         END;
  505.       END;
  506.       *)
  507.       IF found THEN 
  508.         IF accept THEN 
  509.           INC (e^.filtCount); 
  510.           INC (globFiltCount);
  511.         END;
  512.         RETURN accept 
  513.       END;
  514.     END;
  515.     e := Lists.NextEntry (filtList);
  516.   END;
  517.   RETURN grAccept;
  518. END IsBad;
  519.  
  520. PROCEDURE SendMess(msg : CARDINAL; i1 : INTEGER; l : LONGCARD; i2, i3 : INTEGER);
  521. (*
  522.  * AES-Msg an die Hauptapplikation schicken
  523.  *
  524.  *)
  525.  
  526. VAR mess : RECORD
  527.              me: CARDINAL;
  528.              m : ARRAY[1..3] OF INTEGER;
  529.              l : LONGCARD;
  530.              n : ARRAY[6..7] OF INTEGER;
  531.            END;
  532. BEGIN
  533.   mess.me   := msg;
  534.   mess.m[1] := applId;
  535.   mess.m[2] := 0;
  536.   mess.m[3] := i1;
  537.   mess.l    := l;
  538.   mess.n[6] := i2;
  539.   mess.n[7] := i3;
  540.   MagicAES.ApplWrite(0, 16, mess);
  541. END SendMess;
  542.  
  543. PROCEDURE CheckThis();
  544. (*
  545.  * Test einer Msg mit Antwort an Cat
  546.  *
  547.  *)
  548. BEGIN
  549.   INC (messCount);
  550.   IF watchDogActive & IsBad() THEN
  551.     SendMess(HelloWatchDog, CatForget, 0, 0,0);
  552.   ELSE
  553.     SendMess(HelloWatchDog, CatAccept, 0, 0,0);
  554.   END;
  555. END CheckThis;
  556.  
  557. END WatchDog.
  558.